\subsection{Operationen}
\label{subsec:operationen}
In den Abschnitten \ref{subsec:Datentypen} bis \ref{subsec:graphischeDarstellung} wurden die einzelnen Bestandteile von \RENGA vorgestellt. Bisher sind diese Subsysteme getrennt vorgestellt worden. Um sie verwenden zu k\"onnen, ist von Seiten des \textbf{\textit{RENGA}}-Kerns ein einfacher Zugang durch m\"oglichst wenige Klassen w\"unschenswert. Um einen solchen Zugang zu schaffen wurde eine Facade-Klasse \cite{DesignPattern} mit dem Namen Operation, geschaffen. Die Klasse Operation bietet Zugriff auf die einzelnen Subsysteme, indem es Aufrufe nach Vorverarbeitung an die einzelnen Subsysteme delegiert. Abbildung \ref{fig:operations} stellt die bereits implementierten Klassen und ihren Zusammenhang dar.\\

\begin{figure}[htp]
\centering
\includegraphics[scale=0.45,angle=90]{figures/UML-Operations.ps}
\caption{Operation Klassen}
\label{fig:operations}
\end{figure}

\subsubsection{Operation}
Die Operation-Klasse ist die abstrakte Superklasse aller in \RENGA verwendeten Operationen-Klassen. Sie ist gleichzeitig ein Facade-Interface \cite{DesignPattern} f\"ur die Subsysteme: Graphische Darstellung, Ausgabe in XML und Ausf\"uhrung von Operationen. Der gr\"osste Teil der Funktionalit\"at, wie verbinden von Operationen, Weiterleiten der Ver\"anderung der Darstellung an die Visualisation, wurde bereits in dieser Klasse implementiert, so dass Unterklassen im allgemeinen nur die \textit{apply}- und \textit{doubleClick}-Methoden, sowie, f\"ur den Fall dass f\"ur beim Laden Informationen wiederhergestellt werden m\"ussen, die $writeYourself$-Methode \"uberschreiben m\"ussen.  

\subsubsection{PrimitiveOperation}
PrimitiveOperation ist eine der Kernklassen f\"ur die Funktionsweise von \textbf{\textit{RENGA}}. Sie implementieren ein zus\"atzlich zu der bereits von der Klasse Operation implementierten Facede eine weiter f\"ur die in Abschnitt \ref{subsec:Primitive} vorgestellten Primitiven und deren Animationen (Abschnitt \ref{subsec:graphischeDarstellung}). Der Ablauf innerhalb der Klasse ist wie folgt:

Beim Aufruf des Konstruktors:
\begin{enumerate}
\item{Bestimme per Reflection-Mechanismus von Java die Anzahl der Ein- und Ausg\"ange der \"ubergebenen Funktion.}
\item{Setze die Ein- und Ausg\"ange in der Visualisation.}
\item{Bestimme per Reflection-Mechanismus, die Typen der Eing\"ange.}
\end{enumerate}

Beim Aufruf der $apply$-Methode
\begin{enumerate}
\item{Bestimme die Ausgangstypen der Eingangskanten.}
\item{Fordere (falls notwendig) Converter-Objekte aus der ConverterRegistry an.}
\item{Konvertiere die Eingangsobjekte.}
\item{Rufe die primitive Funktion mit konvertierten Werten auf.}
\item{Rufe die Animation mit den konvertierten Werten auf.}
\item{Liefere den angeforderten Ausgabewert zur\"uck.}
\end{enumerate}
Ver\"anderungen an Primitiven sind nicht sinnvoll, daher sollte die $doubleClick$-Methode nicht \"uberschrieben werden.\\
Die $writeYourself$-Methode wurde so \"uberschrieben, dass nach dem Laden die verwendete Funktion und die Animation wieder zur Verf\"ugung stehen das Speichern der Darstellung wird bereits von der Klasse Operation durchgef\"uhrt. 

\subsubsection{CompositeOperation}
\label{subsubsec:CompositeOperationen}
CompositeOperation ist neben PrimitveOperation die zweite Hauptoperation in \textbf{\textit{RENGA}}. Alle in \RENGA erstellten Programme sind von diesem Typ. Wie durch den Namen angedeutet lassen sich durch CompositeOperations durch Kombination von Operationen komplexere erzeugen. CompositOperations stellen dabei in etwa dieselbe Funktionalit\"at wie Subroutinen in klassischen Programmiersprachen bereit. Zu diesem Zweck enthalten CompositeOperation eine Instanz eines Objekts vom Typ Control, dieses Objekt speichert wiederum eine Liste von Klassen des Typs Operation. Um diese Funktionalit\"at bereitzustellen, werden die drei Methoden wie folgt \"uberschrieben.
\begin{itemize}
\item{$apply$: 
\begin{enumerate}
\item{Suche in Control, die FunctionOutputOperation mit der entsprechenden Ausgangszahl}
\item{Fordere das Resultat dieser FunctionOutputOperation an.}
\item{Liefere das berechente Resultat zur\"uck.}
\end{enumerate}}
\item{$doubleClick$:
\"Offnet eine neues Fenster in dem die Funktion bearbeitet werden kann.}
\item{$writeYourself$:
Speichere alle Klassen von Control.}
\end{itemize}

\subsubsection{FunctionInputOperation}
FunctionInputOperations dienen zur Darstellung der Eingangs- und Ausgangsknoten einer CompositeFunction innerhalb der Funktion (nach au"sen hin sind die \"ublichen Verbindungsknoten zu sehen). Das Hinzuf\"ugen einer FunctionInputOperation f\"uhrt dazu, dass die CompositeOperation einen neuen Eingangsknoten erh\"alt.\\
Zus\"atzlich zu den Daten, die bereits von der Klasse Operation gespeichert werden, muss eine FunctionInputOperation speichern, zu welcher CompositOperation sie geh\"ort und welchem Eingang sie entspricht.\\
Neben den Methoden $apply$, die die Verbindung des entsprechenden Eingangsknotens der CompositeOperation abfragt und deren Wert zur\"uckliefert und \textit{double\-Click} die einen einen Dialog \"offnet der es erm\"oglicht einen Initialwert festzulegen muss $writeYourself$ so \"uberschrieben werden, dass die zus\"atzlichen Informationen \"uber den Initialwert und die Eingangsnummer gespeichert werden.\\
Bei der Darstellung muss zu einem Trick gegriffen werden, so besitzt FunctionInputOperation zwar einen Eingang, dieser wird allerdings nicht dargestellt, sondern ist nur durch Verbindung von aussen zu erreichen. 

\subsubsection{FunctionOutputOperation}
FunctionOutputOperation dient einem \"ahnlichen Zweck wie FunctionInputOperation, sie stellt allerdings den Ausgang einer CompositeOperation dar. Sie speichert welcher Ausgang sie ist und zu welcher CompositeOperation sie geh\"ort. \\
Die $apply$-Methode von FunctionOutputOperation fragt den Ausgabewert der vorangeganen Funktion ab und stellt ihn nach aussen zur Verf\"ugung. Die Methode $doubleClick$ hat wie bei PrimitiveOperations keine Funktionali\"at. $writeYourself$ speichert die zus\"atzlichen Werte ab.\\
FunctionOutputOperation greift zu einem \"ahnlichen Trick wie FunctionInputOperation verbirgt den Ausgang und stellt diesen nur nach aussen zur Verf\"ugung.
 
\subsubsection{ConstantOperation}
Um Konstanten zu erstellen wird in \RENGA ConstantOperation verwendet. Die Implementierung dieser Klasse ist denkbar einfach Die $apply$-Methode der Klasse Operation wird durch eine Methode ersetzt, die bei Aufruf den Wert der Variable $toReturn$ zur\"uckgibt. Um diesen Wert zu setzten wird zus\"atzlich die $doubleClick$-Methode \"uberschrieben, so dass sie einen Dialog anzeigt, der das setzten der Variable auf einen beliebigen Wert zul\"asst. Die $writeYourself$-Methode wird so \"uberschrieben, dass der gesetzte Wert nach dem Laden wieder zur Verf\"ugung steht.
\subsubsection{Variable(Put/Get)Operation}
Die Verwendung von Variablen ist in \RENGA gr\"o"stenteils \"uberfl\"ussig, da sie in den meisten F\"allen durch eine weitere Verbindung eines Ausgangs mit dem Eingang der Operation, die die Variable verwenden m\"ochte, ersetzt werden kann. Es existieren allerdings einige F\"alle, in denen dies nicht m\"oglich ist, beispielsweise wenn eine Variable von einer CompositeOperation in eine in sie geschachtelte LoopOperation transportiert werden muss, da LoopOperationen nur eine feste Anzahl von Eing\"angen erlauben. Zu diesem Zweck wurden die beiden Operation VariablePut und VariableGet bereitgestllt. Diese Operationen sind aber keine echten Variablen, sondern funktionieren wie unsichtbare Verbindungslinien.\\
Hierzu wird von einer VariablePutOperation beim Setzen des Namens ($setName$) ein Eintrag in einer zentralen Registry ($VariableRegistry$) vorgenommen. Wird sp\"ater eine VariableGetOperation angelegt, l\"asst sich f\"ur die Variable eine der in der Registry gespeicherten Namen w\"ahlen und es wird eine Verbindung zwischen den beiden Operationen hergestellt, die wie eine einfache Verbindungslinie funktioniert. Zur Sicherstellung, dass keine sp\"ater gel\"oschten Variablen weiterverwendet werden, muss auch bei der Methode $prepareForRemoval$ in VariablePut \"uberschrieben werden, so dass VariableGetOperation \"uber das L\"oeschen informiert werden.\\
Die $apply$-Methode wird so \"uberschrieben, dass der Wert der in VariablePut eingegeben wird, einfach weitergeleitet wird.\\
$writeYourself$ wird so \"uberschrieben, dass jeweils der Name der Variablen gespeichert wird und so sp\"ater passende VariablePut- und VariableGetOperatioen wieder verbunden werden k\"onnen.\\
$doubleClick$ werden jeweils so \"uberschrieben, dass ein Name eingegeben bzw. ausgew\"ahlt werden kann.

\subsubsection{LoopOperation}
Die LoopOperation ist von CompositeOperation abgeleitet und bietet daher ebenfalls ein Control-Objekt und damit die M\"oglichkeit, beliebig komplexe Funktionalit\"aten zu implementieren. Im Gegensatz zu CompositeOperation bestehen aber zwei Unterschiede.
\begin{enumerate}
\item{Die Anzahl der Eing\"ange ist auf zwei beschr\"ankt. Der erste ist der zu verarbeitende Wert, der yweite die Anzahl der Iterationen. Die Anzahl der Ausg\"ange ist beschr\"ankt auf eins.}
\item{Die $apply$-Methode wird ein weiteres Mal \"uberschrieben und funktioniert wie folgt:
\begin{enumerate}
\item{Speichere die beiden Eingangswerte zwischen.}
\item{Setze den Wert von Eingang zwei auf Null.}
\item{Durchlaufe Control wie bei CompositeOperation.}
\item{Setze den Wert von Eingang eins auf den des Ausgangs.}
\item{Z\"ahle den Wert auf Eingang zwei um eins hoch.}
\item{Wiederhole ab (b) bis Eingang zwei den Wert: Iterationen - eins hat.}
\end{enumerate}}
\end{enumerate}